{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "Noisy DQN 除了在网络结构上加入了噪声参数外，其余部分和DQN是一样的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class NoisyLinear(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim, std_init=0.4):\n",
    "        super(NoisyLinear, self).__init__()\n",
    "        \n",
    "        self.input_dim  = input_dim\n",
    "        self.output_dim = output_dim\n",
    "        self.std_init     = std_init\n",
    "        \n",
    "        self.weight_mu    = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n",
    "        self.weight_sigma = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n",
    "        self.register_buffer('weight_epsilon', torch.FloatTensor(output_dim, input_dim))\n",
    "        \n",
    "        self.bias_mu    = nn.Parameter(torch.FloatTensor(output_dim))\n",
    "        self.bias_sigma = nn.Parameter(torch.FloatTensor(output_dim))\n",
    "        self.register_buffer('bias_epsilon', torch.FloatTensor(output_dim))\n",
    "        \n",
    "        self.reset_parameters()\n",
    "        self.reset_noise()\n",
    "    \n",
    "    def forward(self, x):\n",
    "        if self.training: \n",
    "            weight = self.weight_mu + self.weight_sigma.mul(self.weight_epsilon)\n",
    "            bias   = self.bias_mu   + self.bias_sigma.mul(self.bias_epsilon)\n",
    "        else:\n",
    "            weight = self.weight_mu\n",
    "            bias   = self.bias_mu\n",
    "        \n",
    "        return F.linear(x, weight, bias)\n",
    "    \n",
    "    def reset_parameters(self):\n",
    "        mu_range = 1 / math.sqrt(self.weight_mu.size(1))\n",
    "        \n",
    "        self.weight_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.weight_sigma.size(1)))\n",
    "        \n",
    "        self.bias_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.bias_sigma.size(0)))\n",
    "    \n",
    "    def reset_noise(self):\n",
    "        epsilon_in  = self._scale_noise(self.input_dim)\n",
    "        epsilon_out = self._scale_noise(self.output_dim)\n",
    "        \n",
    "        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n",
    "        self.bias_epsilon.copy_(self._scale_noise(self.output_dim))\n",
    "    \n",
    "    def _scale_noise(self, size):\n",
    "        x = torch.randn(size)\n",
    "        x = x.sign().mul(x.abs().sqrt())\n",
    "        return x\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, input_dim,output_dim,hidden_dim=128):\n",
    "        super(Model, self).__init__()\n",
    "        self.fc1 =  nn.Linear(input_dim, hidden_dim)\n",
    "        self.noisy_fc2 = NoisyLinear(hidden_dim, hidden_dim)\n",
    "        self.noisy_fc3 = NoisyLinear(hidden_dim, output_dim)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.noisy_fc2(x))\n",
    "        x = self.noisy_fc3(x)\n",
    "        return x\n",
    "\n",
    "    def reset_noise(self):\n",
    "        self.noisy_fc2.reset_noise()\n",
    "        self.noisy_fc3.reset_noise()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "同 DQN 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        ''' 清空经验回放\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "除了模型需要重置噪声参数外，其余部分和 DQN 一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self,cfg):\n",
    "        self.target_update = cfg.target_update\n",
    "        self.action_dim = cfg.action_dim  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma # 奖励的折扣因子\n",
    "        # e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end =cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.memory = ReplayBuffer(cfg.memory_capacity)\n",
    "        # 当前网络和目标网络\n",
    "        self.policy_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        self.target_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器\n",
    "        self.update_cnt = 0 # 用于延迟更新目标网络的计数\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_values = self.policy_net(state)\n",
    "        action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中随机采样一个批量的样本\n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        actions = torch.tensor(actions, device=self.device).unsqueeze(1)  #  [batch_size, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [batch_size, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "        # 计算当前状态(s_t,a)对应的Q值\n",
    "        q_values = self.policy_net(states).gather(dim=1, index=actions) \n",
    "        # 计算下一时刻的状态(s_t_,a)对应的Q值，注意需要detach()，因为不需要计算梯度\n",
    "        next_q_values_max = self.target_net(next_states).max(1)[0].detach().unsqueeze(1)\n",
    "        # 计算期望的Q值，对于终止状态，此时dones[0]=1, 对应的expected_q_value等于reward\n",
    "        expected_q_values = rewards + self.gamma * next_q_values_max * (1-dones) # [batch_size, 1]\n",
    "         # 计算均方根损失\n",
    "        loss = nn.MSELoss()(q_values, expected_q_values) \n",
    "        # 优化更新模型\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        # 每隔一定步数更新目标网络的参数\n",
    "        if self.update_cnt % self.target_update == 0:\n",
    "            for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "                target_param.data.copy_(param.data)\n",
    "        ## 噪声参数重置\n",
    "        self.policy_net.reset_noise()\n",
    "        self.target_net.reset_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def train(cfg):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n)\n",
    "    policy = Policy(cfg)\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            policy.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{policy.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'NoisyDQN' # 算法名称\n",
    "        self.env_id = 'CartPole-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.train_eps = 100 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.95 # 折扣因子\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 500 # e-greedy策略中epsilon的衰减率\n",
    "        self.memory_capacity = 100000 # 经验回放池的容量\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 64 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t      NoisyDQN      \t   <class 'str'>    \n",
      "       env_id       \t    CartPole-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        100         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "     max_steps      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.95        \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        500         \t   <class 'int'>    \n",
      "  memory_capacity   \t       100000       \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/100，奖励：21.00，Epislon：0.634\n",
      "回合：20/100，奖励：14.00，Epislon：0.460\n",
      "回合：30/100，奖励：12.00，Epislon：0.359\n",
      "回合：40/100，奖励：33.00，Epislon：0.242\n",
      "回合：50/100，奖励：21.00，Epislon：0.160\n",
      "回合：60/100，奖励：40.00，Epislon：0.071\n",
      "回合：70/100，奖励：200.00，Epislon：0.018\n",
      "回合：80/100，奖励：200.00，Epislon：0.010\n",
      "回合：90/100，奖励：200.00，Epislon：0.010\n",
      "回合：100/100，奖励：200.00，Epislon：0.010\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('joyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "996e2c1bcfa8ebbd3aba48733c28d7658f0aec7cda7e9a0e5abbef50d3f90575"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
